//! from into trait
//From
// 对于类型为 U 的对象 foo，如果它实现了 From<T>，那么，可以通过 let foo = U::from(bar) 来生成自己。这里，bar 是类型为 T 的对象。

#[test]
pub fn from_demo(){
    let string = "hello".to_string();
    let other_string = String::from("hello");

    println!("{}", string == other_string);
}

//Into
// 对于一个类型为 U: Into<T> 的对象 foo，Into 提供了一个函数：.into(self) -> T，调用 foo.into() '
// 会消耗自己（转移资源所有权），生成类型为 T 的另一个新对象 bar。

#[test]
pub fn into_demo(){
    let bytes = b"hello".to_vec();
    let s = "hello".to_string();
    let v: Vec<u8> = s.into();
    println!("{}", bytes == v); //true
}

struct Person{
    name: String
}
//实现Into
impl Into<String> for Person {
    fn into(self) -> String {
        return self.name;
    }
}
//实现From
impl From<String> for Person {

    fn from(name: String) -> Self {
        Person{
            name
        }
    }
}

#[test]
pub fn into_demo2(){
    let p = Person{name: String::from("李四")};
    let name: String = p.into();
    println!("{}", name);
   // println!("{}", p.name); //p.name失去字符串的所有权

   let p = Person::from(String::from("李四"));
   println!("{}", p.name);
}